﻿using MemoryViewControl;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;

namespace TestProject
{
    
    
    /// <summary>
    ///This is a test class for MemorySectionTest and is intended
    ///to contain all MemorySectionTest Unit Tests
    ///</summary>
  [TestClass()]
  public class MemorySectionTest
  {


    private TestContext testContextInstance;

    /// <summary>
    ///Gets or sets the test context which provides
    ///information about and functionality for the current test run.
    ///</summary>
    public TestContext TestContext
    {
      get
      {
        return testContextInstance;
      }
      set
      {
        testContextInstance = value;
      }
    }

    #region Additional test attributes
    // 
    //You can use the following additional attributes as you write your tests:
    //
    //Use ClassInitialize to run code before running the first test in the class
    //[ClassInitialize()]
    //public static void MyClassInitialize(TestContext testContext)
    //{
    //}
    //
    //Use ClassCleanup to run code after all tests in a class have run
    //[ClassCleanup()]
    //public static void MyClassCleanup()
    //{
    //}
    //
    //Use TestInitialize to run code before running each test
    //[TestInitialize()]
    //public void MyTestInitialize()
    //{
    //}
    //
    //Use TestCleanup to run code after each test has run
    //[TestCleanup()]
    //public void MyTestCleanup()
    //{
    //}
    //
    #endregion


    /// <summary>
    ///A test for MemorySection Constructor
    ///</summary>
    [TestMethod()]
    public void MemorySectionConstructorTest()
    {
      uint address = 0;
      uint size = 0;
      MemorySection.Flags flags = MemorySection.Flags.None; // TODO: Initialize to an appropriate value
      string name = "Test Section";
      int bits = 8;
      MemorySection target = new MemorySection(address, size, flags, name, bits);
      Assert.AreEqual(address, target.StartAddress);
      Assert.AreEqual(size, target.size);
      Assert.AreEqual(address+size, target.EndAddress);
      Assert.AreEqual(flags, target.flags);
      Assert.AreEqual(name, target.Name);
      Assert.AreEqual(bits, target.ByteWidth);
    }

    /// <summary>
    ///A test for MemorySection Constructor
    ///</summary>
    [TestMethod()]
    public void MemorySectionConstructorTest1()
    {
      MemorySection target = new MemorySection();
      Assert.Inconclusive("TODO: Implement code to verify target");
    }

    /// <summary>
    ///A test for CalculateVisibleLines
    ///</summary>
    [TestMethod()]
    public void CalculateVisibleLinesTest()
    {
      MemorySection target = new MemorySection(); // TODO: Initialize to an appropriate value
      uint alignment = 0; // TODO: Initialize to an appropriate value
      uint width = 0; // TODO: Initialize to an appropriate value
      bool renderHidden = false; // TODO: Initialize to an appropriate value
      bool renderInvalid = false; // TODO: Initialize to an appropriate value
      int expected = 0; // TODO: Initialize to an appropriate value
      int actual;
      actual = target.CalculateVisibleLines(alignment, width, renderHidden, renderInvalid);
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for ClearChanged
    ///</summary>
    [TestMethod()]
    public void ClearChangedTest()
    {
      MemorySection target = new MemorySection(); // TODO: Initialize to an appropriate value
      target.ClearChanged();
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for ClearHidden
    ///</summary>
    [TestMethod()]
    public void ClearHiddenTest()
    {
      MemorySection target = new MemorySection(); // TODO: Initialize to an appropriate value
      target.ClearHidden();
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for Compare
    ///</summary>
    [TestMethod()]
    public void CompareTest()
    {
      MemorySection lhs = null; // TODO: Initialize to an appropriate value
      MemorySection rhs = null; // TODO: Initialize to an appropriate value
      int expected = 0; // TODO: Initialize to an appropriate value
      int actual;
      actual = MemorySection.Compare(lhs, rhs);
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for Cool
    ///</summary>
    [TestMethod()]
    public void CoolTest()
    {
      MemorySection target = new MemorySection(); // TODO: Initialize to an appropriate value
      float amount = 0F; // TODO: Initialize to an appropriate value
      target.Cool(amount);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for SetDirty
    ///</summary>
    [TestMethod()]
    public void SetDirtyTest()
    {
      MemorySection target = new MemorySection(); // TODO: Initialize to an appropriate value
      target.SetDirty();
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for SetDirty
    ///</summary>
    [TestMethod()]
    public void SetDirtyTest1()
    {
      MemorySection target = new MemorySection(); // TODO: Initialize to an appropriate value
      uint address = 0; // TODO: Initialize to an appropriate value
      uint size = 0; // TODO: Initialize to an appropriate value
      target.SetDirty(address, size);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for SetHidden
    ///</summary>
    [TestMethod()]
    public void SetHiddenTest()
    {
      MemorySection target = new MemorySection(); // TODO: Initialize to an appropriate value
      uint address = 0; // TODO: Initialize to an appropriate value
      uint size = 0; // TODO: Initialize to an appropriate value
      bool hidden = false; // TODO: Initialize to an appropriate value
      target.SetHidden(address, size, hidden);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for SetHighlight
    ///</summary>
    [TestMethod()]
    public void SetHighlightTest()
    {
      MemorySection target = new MemorySection(); // TODO: Initialize to an appropriate value
      uint address = 0; // TODO: Initialize to an appropriate value
      uint size = 0; // TODO: Initialize to an appropriate value
      int highlight = 0; // TODO: Initialize to an appropriate value
      target.SetHighlight(address, size, highlight);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for SetHighlight
    ///</summary>
    [TestMethod()]
    public void SetHighlightTest1()
    {
      MemorySection target = new MemorySection(); // TODO: Initialize to an appropriate value
      int highlight = 0; // TODO: Initialize to an appropriate value
      target.SetHighlight(highlight);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for SetMemory
    ///</summary>
    [TestMethod()]
    public void SetMemoryTest()
    {
      MemorySection target = new MemorySection(); // TODO: Initialize to an appropriate value
      uint address = 0; // TODO: Initialize to an appropriate value
      byte[] data = null; // TODO: Initialize to an appropriate value
      target.SetMemory(address, data);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for SetMemory
    ///</summary>
    [TestMethod()]
    public void SetMemoryTest1()
    {
      MemorySection target = new MemorySection(); // TODO: Initialize to an appropriate value
      uint address = 0; // TODO: Initialize to an appropriate value
      byte[] data = null; // TODO: Initialize to an appropriate value
      uint size = 0; // TODO: Initialize to an appropriate value
      target.SetMemory(address, data, size);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for UpdateBank
    ///</summary>
    [TestMethod()]
    public void UpdateBankTest()
    {
      MemorySection target = new MemorySection(); // TODO: Initialize to an appropriate value
      uint address = 0; // TODO: Initialize to an appropriate value
      uint size = 0; // TODO: Initialize to an appropriate value
      target.UpdateBank(address, size);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for UpdateMemory
    ///</summary>
    [TestMethod()]
    public void UpdateMemoryTest()
    {
      MemorySection target = new MemorySection(); // TODO: Initialize to an appropriate value
      uint address = 0; // TODO: Initialize to an appropriate value
      byte[] data = null; // TODO: Initialize to an appropriate value
      bool setChanged = false; // TODO: Initialize to an appropriate value
      target.UpdateMemory(address, data, setChanged);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for UpdateMemory
    ///</summary>
    [TestMethod()]
    public void UpdateMemoryTest1()
    {
      MemorySection target = new MemorySection(); // TODO: Initialize to an appropriate value
      uint address = 0; // TODO: Initialize to an appropriate value
      ushort[] data = null; // TODO: Initialize to an appropriate value
      bool setChanged = false; // TODO: Initialize to an appropriate value
      target.UpdateMemory(address, data, setChanged);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for UpdateMemory
    ///</summary>
    [TestMethod()]
    public void UpdateMemoryTest2()
    {
      MemorySection target = new MemorySection(); // TODO: Initialize to an appropriate value
      uint address = 0; // TODO: Initialize to an appropriate value
      byte[] data = null; // TODO: Initialize to an appropriate value
      uint size = 0; // TODO: Initialize to an appropriate value
      bool setChanged = false; // TODO: Initialize to an appropriate value
      target.UpdateMemory(address, data, size, setChanged);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for UpdateMemory
    ///</summary>
    [TestMethod()]
    public void UpdateMemoryTest3()
    {
      MemorySection target = new MemorySection(); // TODO: Initialize to an appropriate value
      uint address = 0; // TODO: Initialize to an appropriate value
      ushort[] data = null; // TODO: Initialize to an appropriate value
      uint size = 0; // TODO: Initialize to an appropriate value
      bool setChanged = false; // TODO: Initialize to an appropriate value
      target.UpdateMemory(address, data, size, setChanged);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for UpdateRead
    ///</summary>
    [TestMethod()]
    public void UpdateReadTest()
    {
      MemorySection target = new MemorySection(); // TODO: Initialize to an appropriate value
      uint address = 0; // TODO: Initialize to an appropriate value
      uint size = 0; // TODO: Initialize to an appropriate value
      target.UpdateRead(address, size);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for ByteWidth
    ///</summary>
    [TestMethod()]
    public void ByteWidthTest()
    {
      MemorySection target = new MemorySection(); // TODO: Initialize to an appropriate value
      int actual;
      actual = target.ByteWidth;
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for DataMask
    ///</summary>
    [TestMethod()]
    public void DataMaskTest()
    {
      MemorySection target = new MemorySection(); // TODO: Initialize to an appropriate value
      int actual;
      actual = target.DataMask;
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for EndAddress
    ///</summary>
    [TestMethod()]
    public void EndAddressTest()
    {
      MemorySection target = new MemorySection(); // TODO: Initialize to an appropriate value
      ulong actual;
      actual = target.EndAddress;
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for Length
    ///</summary>
    [TestMethod()]
    public void LengthTest()
    {
      MemorySection target = new MemorySection(); // TODO: Initialize to an appropriate value
      uint actual;
      actual = target.Length;
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for Name
    ///</summary>
    [TestMethod()]
    public void NameTest()
    {
      MemorySection target = new MemorySection(); // TODO: Initialize to an appropriate value
      string actual;
      actual = target.Name;
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for StartAddress
    ///</summary>
    [TestMethod()]
    public void StartAddressTest()
    {
      MemorySection target = new MemorySection(); // TODO: Initialize to an appropriate value
      uint actual;
      actual = target.StartAddress;
      Assert.Inconclusive("Verify the correctness of this test method.");
    }
  }
}
